Method and system for multi-character multi-pattern pattern matching

ABSTRACT

Disclosed is a method and system for multi-character multi-pattern pattern matching. In the multi-character multi-pattern pattern matching method, patterns in an input stream are detected by transitioning between states of a “compressed deterministic finite state automaton (DFA)”, with each transition based on multiple characters of the input stream. The compressed DFA is created by compressing an original DFA, such as an Aho-Corasick DFA, such that each state of the compressed DFA represents multiple consecutive states of the original DFA and each transition between the states of the compressed DFA is a combination of all of the transitions between the multiple consecutive states of the original DFA. This method can be implemented using a Ternary Content-Addressable Memory (TCAM) to store the transitions of the compressed DFA and compares the transitions with multiple characters of an input stream at a time to detect patterns in the input stream.

BACKGROUND OF THE INVENTION

The present invention is generally directed to pattern matching. More specifically, the present invention is directed to a method and system for multi-character multi-pattern pattern matching.

Pattern matching is used to detect the occurrence of a pattern or keyword in a search target. For example, given two strings, a simple pattern matching algorithm can detect the occurrence of one of the strings in the other. Pattern matching algorithms are widely used in information retrieval applications, such as data mining, bibliographic searching, search and replace text editing, word processing, etc., and content inspection applications, such as Network Intrusion Detection Systems (NIDS), virus/worm detection using signature matching, IP address lookup in network routers, DNA sequence matching, etc.

For many applications, it is necessary to detect multiple patterns in a particular search target. A conventional multi-pattern pattern matching algorithm is the Aho-Corasick (AC) algorithm. The AC algorithm locates all occurrences of any of a finite number of keywords in a string by constructing a finite state pattern matching machine to process the string in a single pass. For example, this algorithm can be used to detect virus/worm signatures in a data packet stream by running the data packet stream through the finite state machine byte by byte.

The AC algorithm constructs the finite state machine in three pre-processing stages, namely the goto stage, the failure stage, and the next stage. In the goto stage, a deterministic finite state automaton (DFA) or keyword trie is constructed for a given pattern set. The DFA constructed in the goto stage includes various states for an input string, and transitions between the states based on characters of the input string. Each transition between states in the DFA is based on a single character of the input string. The failure and next stages add additional transitions between the states of the DFA to ensure that a string of length n can be searched in exactly n cycles. Essentially, these additional transitions help the algorithm to slide from the currently matched pattern (not a match anymore) to another pattern which is the next best (longest prefix) match in the DFA. Once the pre-processing has been performed, the DFA can then be used to search any target for all of the patterns in the pattern set.

During the search stage, the AC DFA processes one character (or byte) per transition in the DFA, and each transition is stored in a memory. Accordingly, the AC DFA transitions to a different state based on each character of the input string. Hence, for each character in an input string, a memory lookup operation must be performed to access the transitions from the current state of the AC DFA and compare the transitions to the character.

Virus/worm detection applications must detect the presence of multiple virus/worm signatures in a stream of packets in a single pass as the packets are transmitted in a data network. As network speeds have increased, conventional pattern matching algorithms, such as the AC algorithm, cannot perform at high enough speeds to keep up the network speeds. One reason that conventional pattern matching algorithms cannot perform at high speeds is because a memory lookup operation must be performed for each byte of the stream of packets.

What is needed is a multi-pattern matching method that can be used for high speed applications.

BRIEF SUMMARY OF THE INVENTION

The present invention provides a method for multi-pattern pattern matching that processes multiple characters of an input stream for each transition between states. This method provides higher pattern matching speeds and can be used with high speed applications. The present invention also provides a system capable of optimal implementation of the multi-character multi-pattern matching method.

According to an embodiment of the present invention, all occurrences of multiple patterns in an input stream are detected by transitioning between multiple states of a compressed deterministic finite state automaton (DFA), each transition based on multiple characters of the input stream. The compressed DFA can be generated by constructing an original DFA, such as an Aho-Corasick DFA, and compressing the original DFA such that each state of the compressed DFA represents multiple consecutive states of the original DFA. The transitions between the states of the compressed DFA are combinations of all of the transitions between the consecutive multiple states of the original DFA.

In an embodiment of the present invention, regular expressions, made up of multiple sub patterns and wildcards, are split up into the multiple sub patterns, and each sub pattern is separately included in the compressed DFA. When patterns are detected in an input stream, the regular expression can be identified based on the sub patterns being detected at specified offsets corresponding to the regular expression.

According to an embodiment of the present invention, a system for implementing a multi-character multi-pattern pattern matching method includes a Ternary Content-Addressable Memory (TCAM) and a Static Random Access Memory (SRAM). The TCAM stores entries, each entry including a state of a compressed DFA and a multiple character transition from that state. The SRAM stores a next state of the compressed DFA, input length value, and a detected patterns list corresponding to each entry of the TCAM. The TCAM compares an input stream, multiple characters at a time, to the entries of the TCAM. If a matching entry is found in the TCAM, an address to a location in the SRAM of the corresponding next state, input value length, and detected patterns list is returned. By repeating this procedure, the TCAM compares all of the characters of the input stream to the entries of the TCAM and detects all of the patterns in the input stream by transitioning based on multiple characters.

These and other advantages of the invention will be apparent to those of ordinary skill in the art by reference to the following detailed description and the accompanying drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates a method for multi-character multi-pattern pattern matching according to an embodiment of the present invention;

FIG. 2 illustrates an exemplary goto graph for an Aho-Corasick (AC) deterministic finite state automaton (DFA);

FIG. 3 illustrates exemplary next transitions on the goto graph of FIG. 2 for an AC DFA;

FIG. 4 is pseudo code of a goto algorithm of a compressed DFA;

FIG. 5 illustrates an exemplary goto graph of a compressed DFA;

FIG. 6 is pseudo code of an algorithm for safe state computation;

FIG. 7 is pseudo code of an algorithm for computing next transitions for a compressed DFA;

FIG. 8A illustrates an exemplary original DFA;

FIG. 8B illustrates an exemplary compressed DFA corresponding to the original DFA of FIG. 8A and including a forward next transition;

FIG. 8C illustrates an exemplary compressed DFA corresponding to the original DFA of FIG. 8A and including a backward next transition;

FIG. 9 illustrates an exemplary compressed DFA corresponding to the original DFA of FIG. 3;

FIG. 10 is pseudo code of an algorithm for generating shallow states in a compressed DFA;

FIG. 11 illustrates an exemplary compressed DFA with shallow states;

FIG. 12 illustrates a multi-character multi-pattern pattern matching system according to an embodiment of the present invention; and

FIG. 13 is a high level block diagram of a computer.

DETAILED DESCRIPTION OF THE INVENTION

FIG. 1 illustrates a method for multi-character multi-pattern pattern matching according to an embodiment of the present invention. This method is used to detect a finite number of keywords (patterns) in an input stream. Thus, given a pattern database storing multiple patterns, this method detects all occurrences of each pattern in an input stream. The input stream can be, for example, a string of text or a stream of data packets, but the present invention is not limited thereto. The input stream can be any bit-stream, and the patterns can be any bit-stream as well. The input stream is made up of characters. As used herein, the term character refers to any basic unit of the input stream. The pattern matching is performed on the basis of the characters of the input stream. The characters of the input stream are not limited to ASCII characters, as the algorithm works for any data representation. For example, the term character may refer to letters of a text string and bytes of a data packet stream. A character may also refer to a bit in a binary bit stream. Accordingly, what “character” is being used as a basis for the pattern matching depends on a granularity of the pattern matching.

The method of FIG. 1 generates an original deterministic finite state automaton (DFA) and a compressed DFA. Listed below are functions that are used throughout this method. Since the same function names are used for the original DFA and the compressed DFA, the subscripts o and c are used to distinguish the original DFA and the compressed DFA, respectively.

-   goto_(o),(s_(o),a) The goto function of the original DFA. The DFA in     state s_(o) teaches the state goto_(o)(s_(o),a) on the input     character α. -   fail_(o)(s_(o)) The failurefunction of the original DFA. The DFA in     state s_(o) is equivalent to the state fail(s_(o)), as the string     representing fail(s_(o)) is a suffix of the string representing     s_(o). -   next_(i)(s_(o),α) The next function of the original DFA. The DFA in     state s_(o) reaches the state next_(o)(s_(o), α) on the input     character α. -   output_(o)(s_(o)) The output function of the original DFA. The DFA     in state s_(o) indicates that output_(o)(s_(o)) patterns have been     matched. -   goto_(c)(s_(c),inp) The goto function of the compressed DFA. The DFA     in state s_(c) reaches the state goto_(c)(s_(c), inp) on input     string inp and consumes all the characters in the input. -   next_(c)(s_(c),inp,len) The next function of the compressed DFA. The     DFA in state s_(c) reaches the state next_(c)(s_(c),inp,len) on the     input string inp and consumes len characters, len can be less than     the length of the string inp. In those cases remaining characters in     the string serve as a look-ahead. In some cases len can be negative;     Here, the input pointer is moved back by the amount |len|. -   output_(c)(s₁,s₂,inp) The output function of the compressed DFA. The     DFA in state s₁, when it reaches the state s₂, on the input string     inp, indicates that output_(c)(s₁,s₂,inp) patterns have been     matched. -   root is the start state (start 0) in the DFA. The root of both the     original DFA and the compressed DFA is denoted by the same notation.

parent(s) is the parent state of s in the goto graph. depth(s) is the depth of state s in the DFA.

-   string(s) is the minimum input string that will take the DFA from     the root to the state s. The operators + on strings are used to     denote the concatenation. The operator − is used for the string     difference. String difference is defined for two strings str₁ an+ -   d str₂, if one is a prefix of the other. -   dist(s₁,s₂) is defined as the length of string(s₂)-string(s₁), where     string(s₁) is a prefix of string(s₂). -   core state is that state that is at a depth, that is a multiple of K     (where K is the maximum number of characters consumed in a single     transition in the compressed DFA) in the original DFA or that state     where a pattern starting at the root terminates in the original DFA. -   skick(s_(o)) The sidekick of state s_(o) in the original DFA is the     corresponding state in the compressed DFA, if it is a core state. If     s_(o) is a non-core state, it points to the sidekick states of all     the states in the original DFA that can be reached in less than K     goto transitions, chosen uniquely. -   output(s₁,s₂,n) is defined as the union of the output function of     the first n states reached when traversing from s₁ to s₂ in the     original DFA, including s₂ but excluding s₁. If n is undefined, it     takes the maximum permissible value (depth(s₂)−depth(s₁)). If s₁ or     s₂ represent states in the compressed DFA, the corresponding core     states in the original DFA that have a sidekick to these states are     considered. -   cParent(s_(o)) The compressed parent of a state s_(o) in the     original DFA is defined as the sidekick state if s_(o) is a core     state or the parent of the sidekick state if it is a non-core state.

Referring to FIG. 1, at step 110, wildcards are removed from the pattern database by splitting patterns with wildcards into multiple sub patterns. A pattern with wildcards is referred to herein as a regular expression. Any regular expression S can be decomposed into sub patterns. For example, S can be given by s1???s2*s3, where s1, s2, and s3 are each simple patterns, and broken into the sub patterns of s1, s2, and s3. The sub patterns can be implemented in the pattern database as three different patterns.

At step 120, an original deterministic finite state automaton (DFA) is constructed for the patterns in the pattern database. According to an embodiment of the present invention, the original DFA can be constructed using the Aho-Corasick (AC) algorithm. The AC algorithm is described in greater detail in A. V. Aho and M. J. Corasick, “Efficient string matching: an aid to bibliographic search,” Comm. ACM, vol. 18, no. 6, pp. 333-340, June 1975. The AC DFA is constructed by constructing a trie of the patterns using a goto function, computing a failure function, and constructing an additional set of transitions using a next function. The goto function is used to construct an initial finite state machine called a goto graph. A goto graph is made up of vertices representing states and edges connecting the vertices representing transitions between the states. FIG. 2A illustrates an exemplary goto graph for an AC DFA. The goto graph is constructed starting with one vertex 202, called the root state 202, which represents state 0. Each pattern is then entered into the graph by adding to the graph a directed path that begins at the root state 202. New vertices 204 and edges 206, representing states and transitions, respectively, are added to the graph so that there will be, starting at the root state 202, a path in the graph that spells out each pattern. FIG. 2 shows an exemplary goto graph for three patterns, ABCDEFGHIJK, WXYZABCDIJ, and WXYZAB. As illustrated in FIG. 2, each transition in the goto graph is based on one character.

The patterns entered into the original DFA in the goto stage could possibly satisfy a property that a sub-sequence that is a prefix of one pattern is a suffix of another pattern. Thus, when traversing the part of the original DFA that represents the sub-sequence in the pattern where it is a suffix, a possible match could be indicated for both patterns. Hence, the failure function is defined for the original DFA to shift from one pattern to another pattern at the sub-sequence boundary when no more of the longer pattern is being matched. The next function for the original DFA improves upon the failure function to guarantee a single character consumption for every transition, at the cost of a larger DFA. The next function adds next transitions to the goto graph. FIG. 3 illustrates an exemplary DFA corresponding to the goto graph of FIG. 2 including next transitions. As illustrated in FIG. 3, the sub-sequence ABCD occurs in the pattern WXYZABCDIJ and the pattern ABCDEFGHIJK. Thus, if the sub-sequence ABCD occurs directly after WXYZ, the input stream would be at state 19. However, because the sub-sequence can be part of the pattern ABCDEFGHIJK as well as WXYZABCDIJ, a next transition 302 is added between state 19 and state 5 based on the character E. Thus, at state 19, if the character E is detected, the DFA transitions to state 5. Furthermore, a pattern can begin at any state. For example, if the character A or W is detected at state 2, that character could be the beginning of the pattern ABCDEFGHIJK or WXYZABCDIJ, respectively. Accordingly, next transitions 304 and 306 are added between state 2 and states 1 and 12, respectively. Although not illustrated in FIG. 3, similar next transitions can be added for all of the other states (except state 15 which has a next transition only to state 12).

Returning to FIG. 1, at step 130, a compressed DFA is generated based on the original DFA. Each state of the compressed DFA represents up to K consecutive states of the original DFA. Each transition of the compressed DFA is based on multiple characters. For each state in the original DFA which has a depth that is a multiple of K, a corresponding compressed DFA state is constructed. A compressed DFA state is also constructed for each state in the original DFA where a pattern that starts at the root terminates. The states of the original DFA for which there is a corresponding state in the compressed DFA are called core states. The subset of core states which correspond to pattern terminating states are specifically called end core states. Two core states are considered to be adjacent if the directed path length between them is at most K. The goto function of the compressed DFA is derived from the consecutive goto transitions between adjacent core states of the original DFA. The next function of the compressed DFA is derived from the next transitions of the original DFA.

A many-to-many mapping (called a sidekick) from the original DFA to the compressed DFA is created. Every core state of the original DFA uniquely maps to its corresponding compressed state. All of the non-core states in the path between two adjacent core states s1 _(o) and s2 ₀ (depth(s1 _(o))<depth(s2 _(o))) maps to the sidekick of s2 _(o). There may be multiple elements in the sidekick of a non-core state, if that state is part of multiple patterns. The sidekick of any original DFA state s_(o) is thus the closest compressed DFA state s_(c), such that 0<=dist (s_(o), s_(c)) <K.

A function cParent is defined for the states of the original DFA as follows: If the state is a core state, then cParent of the state is its sidekick state; if the state is a non-core state, then cParent is the parent of any of its sidekicks. Note that the parents of all sidekick states of a non-core state are the same. Thus, if the transitions are only goto transitions, the compressed DFA would be on the state cParent(state_(o)), if the original DFA reaches state. The cParent of any original DFA state s_(o) is thus the closest compressed DFA state s_(c), such that 0<=dist (s_(c), s_(o))<K.

FIG. 4 is pseudo code for the goto algorithm of the compressed DFA. This algorithm generates a compress goto graph by doing a depth first search on the original goto graph. A depth first search starts from the root of the goto graph and searches all the nodes that are one-hop away first, then all the nodes that are two-hops away, and so on until all the nodes in the goto graph have been covered. During the depth first search, the algorithm keeps track of the compressed state corresponding to the preceding core state (parent_(c)), and the part of the pattern starting from that state (input). In the pseudo code identified by 410, if the current state is a core state (i.e., the depth is a multiple of K or a pattern-end state), the algorithm creates a new compressed state. A goto transition on the string input is created from the parent to the new state. The new state becomes the new parent and the input is reset to null. The sidekick and the cParent of the core state will become the new state. In the pseudo code identified by 420, if a state is not a core state, sidekick information is populated from its child states. This algorithm is recursively called for all children in the original goto graph, with the transition character from each state appended to the input string. Similarly, even information regarding the output function is also appropriately updated at each state. This algorithm generates a compressed goto graph which is an accurate representation of the original goto graph.

FIG. 5 illustrates an exemplary goto graph of a compressed DFA. The compressed goto graph of FIG. 5 corresponds to the original goto graph of FIG. 2 for K=4. Similar to the goto graph of FIG. 2, the patterns of the compressed goto graph are ABCDEFGHIJK, WXYZABCDIJ, and WXYZABPQ. Since K=4, the core states of the original DFA are states 0, 4, 8, 11, 15, 19, 21, and 23, with states 11, 21, and 23 being end core states. Accordingly, the states 502 of the compressed goto graph correspond to these core states. Note that the states 502 of the compressed goto graph are labeled using the same state numbers as the corresponding core states for consistency. Furthermore, each of the transitions 504 between the states 502 of the compressed goto graph is based on multiple characters. Each transition 504 of the compressed goto graph is generated by combining the consecutive transitions of the original goto graph between adjacent core states.

Once the goto transitions of the compressed DFA are generated, the next transitions of the compressed DFA can be generated. In an AC DFA, most of the next transitions are to states of depth m or less, where m is a small threshold number. In order to save memory, it is possible to ignore transitions to states of depth m or less, and account for these transitions directly in the hardware at the expense of increased length for state identifiers (this is described in greater detail below).

Since the compressed DFA has only states corresponding to the core states of the original DFA, the non-core next transitions of the original DFA must be mapped to the compressed DFA. This can be done by generating next transitions between the cParent of the source node and the sidekicks or cParent of the destination node and modifying the input string for the transitions accordingly. Let next_(o)(s_(o),a) be d_(o) ^(i). Let d_(o) ¹ and d_(o) ^(k) be adjacent core states such that d_(o) ^(i) is in the path between d_(o) ¹ and d_(o) ^(k). Note that there can be multiple such d_(o) ^(k). Let d_(o) ¹, d_(o) ², . . . , d_(o) _(i), . . . , d_(o) ^(k) be the path between d_(o) ¹ and d_(o) ^(k) in the goto graph. If there is no next transition to a state of depth more than m from any of d_(o) ¹, . . . , d_(o) ^(k), then a next transition can be generated from cParent(s_(o)) to sidekick(d_(o) ^(i)). Such a d_(o) ^(i) is called a safe state. If the next transition is to a state that is not safe, then such a transition can not guarantee correctness. A Boolean function safe can be used to indicate whether a state is safe.

FIG. 6 is pseudo code for an algorithm for safe state computation. In the pseudo code identified by 610, the algorithm sets a safe value of a state of the original DFA to true if there are no next transitions to a state of depth greater than m. In the pseudo code identified by 620, the safe value of the state is changed to false if any of the children of that state have a next transition to a state of depth greater than m. In the pseudo code identified by 630, the safe value of a core state is set to true. Thus, the algorithm determines a state to be safe if the state is a core state or the state does not have a next transition to a depth greater than m, and all of its children are safe. This algorithm computes the value of the safe function for each of the states of the original DFA.

In order to generate the next transitions of the compressed DFA, every next transition of the original DFA is mapped to one or more next transitions of the compressed DFA. For every next transition of the original DFA next_(o)(s_(o),a)=d_(o), a next transition of the compressed DFA next_(c) is generated from cParent(s_(o)) either to cParent(d_(o)) (referred to as a backward next transition) or to all the states in the sidekick(d_(o)) (referred to as a forward next transition), based on the length of the transition and whether the state d_(o) is safe. Note that the forward transition will process more input characters and hence has a better throughput than the backward transition, but it is not always possible to generate a forward transition if d_(o) is not a safe state or the input length of the forward transition is greater than a threshold. According to an embodiment of the present invention, the threshold can be the value K, but the present invention is not limited thereto (the threshold and K can correspond to a width of a Ternary Content-Addressable Memory which will be described in greater detail below).

FIG. 7 is pseudo code for an algorithm for computing next transitions of the compressed DFA. In the pseudo code identified by 710, a next transition for the compressed DFA is created corresponding to a next transition of the original DFA. More particularly, the pseudo code identified by 710 determines whether to create a forward or backward next transition, and accordingly invokes the pseudo code identified by 720 or 730 to execute the forward or backward transition, respectively. In the pseudo code identified by 720, a forward next transition for next_(o)(s_(o),a)=d_(o) is formed when d_(o) is safe and a length of the transition for cParent(s_(o)) to all states in the sidekick(d_(o)) is less than or equal to the threshold. The transition is based on input string(s_(o))−string(cParent(s_(o)))+a+string(sidekick(d_(o)))−string(d_(o))) and processes all of the input (i.e., dist(s_(o),cParent(s_(o))+dist(sidekick(d_(o)),d_(o))+1 characters, where dist(s₂,s₁) is the difference between the length of string(s₂) and string(s₁)). FIGS. 8A and 8B illustrate an exemplary original DFA and an exemplary compressed DFA having a forward next transition 804. As illustrated in FIG. 8A, in the original DFA, a next transition 802 based on E exists from a state between core states 3 and 4 to a state between core states 1 and 2. As illustrated in FIG. 8B, the forward next transition 804 is generated from state 3 to state 2 of the compressed DFA based on ABEFG (the combination of all of the transitions between state 3 and state 2 of the original DFA).

Returning to FIG. 7, in the pseudo code identified by 730, a backward next transition for next(s_(o),a)=d_(o) is formed when d_(o) is not a safe state or a length of the transition from cparent(s_(o)) to all the states in sidekick(d_(o)) is more than the threshold. The backward next transition is based on input string(s_(o))−string(cParent(s_(o)))+a and processes dist(s_(o),cParent(s_(o)))−dist (d_(o),cParent(d_(o)cParent(d_(o)))+1. FIG. 8C illustrates an exemplary compressed DFA having a backward next transition 806 corresponding to the next transition 802 of the original DFA of FIG. 8A. As illustrated in FIG. 8C, the backward next transition 806 is generated from state 3 to state 1 in the compressed DFA based on the characters ABE,1. This notation means that the compressed DFA transitions from state 3 to state 1 based on ABE, and then for the next pattern matching memory lookup, the input stream starts from one position ahead of its current position, meaning 1 character has been consumed. If no number is indicated, it defaults to the length of the string.

FIG. 9 illustrates an exemplary compressed DFA corresponding to the original DFA of FIG. 3. As illustrated in FIG. 9, a next transition 910 from state 19 to state 8 of the compressed DFA is based on EFGH. The effect of this next transition is the same of the next transition 302 from state 19 to state based on E in the original DFA. Furthermore, original next transitions 304 and 305 are to states having depths less than m, and are ignored in the compressed DFA.

A potential problem with the compressed DFA is that a pattern can be missed if the pattern does not start at a position of the input that is multiple of K. For example, if K=4 and the pattern is ABCDEFGHIJKL, there will be a transition from state 0 to state 1 of the compressed DFA on the input ABCD. But, if the input string is XXABCDEFGHIJKL, the compressed DFA will not recognize the pattern since neither XXAB nor CDEF have any transition from state 0. Thus, in order for the compressed DFA to work correctly, the input must be “synchronized” with the compressed DFA. This can be achieved by generating a state in the compressed DFA corresponding to each state in the original DFA whose depth is less than K. Such states in the original DFA are called original shallow states, and such states in the compressed DFA are called compressed shallow states.

FIG. 10 is pseudo code of an algorithm for generating shallow states in the compressed DFA. In the pseudo code identified by 1010, a transition is generated from the root state to each compressed shallow state s_(c) as follows: Let i be the length of string(s_(c)); then goto_(c)(0, ?^(K-i)+string(s_(c)))=s_(c), where ?^(K-i) represents any K-i characters. In the pseudo code identified by 1020, goto transitions are added from each compressed shallow state s_(c) to the compressed states d_(c) corresponding to the nearest core states (i.e., goto(s_(c), string(d_(c))−string(s_(c)))=d_(c)).

FIG. 11 illustrates an example of a compressed DFA with compressed shallow states. As illustrated in FIG. 7, shallow states 3 1102, 4 1104, and 5 1106 are added to the compressed DFA for the pattern ABCDEFGH with K=4. Thus, for any number of characters input before ABCD, the compressed DFA reaches state 1 of the compressed DFA which corresponds to the first core state of an original DFA. In order to reach state 1, the compressed DFA will either take one direct transition or two transitions through an intermediate shallow state 1102, 1104, or 1106. In the case of one direct transition, K characters are processed in one cycle, and in the case of two transitions through a shallow state, at least K+1 characters are processed in two cycles. Along similar lines, to increase throughput, it is possible to generate shallow states for each of the states of depth less than rK (r≧1) in the original DFA. In this case, a throughput of rK+1 characters in r+1 cycles can be achieved, if only goto transitions occur.

Due to the addition of shallow states, there might be multiple transitions on the same input from a state. For example, if the pattern strings are ABCDEFGH and CDEFGHIJ, on input ABCDEFGH, there are matching transitions from the state 0: one for ABCD and the other for ??CD. In this case, transition to a state whose pattern is of longer length (ignoring don't-care symbols ?) takes precedence.

FIG. 12 illustrates a multi-character multi-pattern pattern matching system 1200 according to an embodiment of the present invention. Referring to FIG. 12, the system 1200 includes a Ternary Content-Addressable Memory (TCAM) 1202 and static random access memory (SRAM) 1204. The TCAM 1202 is used to store the state transitions of the compressed DFA. Returning to FIG. 1, at step 140, the compressed DFA is stored in the TCAM 1202 and the SRAM 1204. The transitions (both goto and next) of the compressed DFA are represented as entries in the TCAM 1202. Each TCAM entry consists of a (state, input) pair which represents a corresponding transition of the compressed DFA. The address of each TCAM entry points to a memory location in the SRAM 1204, which contains the next state for the transition, a number of input characters to be processed by the DFA, and a list of output patterns detected upon reaching this transition. The list of output patterns (output function) associated with a transition includes all previous undetected patterns which are detected as a result of that transition. Note that according to an embodiment of the present invention, the output function is associated with the transitions, not with the states as in the conventional AC algorithm. Accordingly, transitions act as triggers in outputting that a pattern is detected. Although the SRAM 1204 is utilized in conjunction with the TCAM 1202 in the embodiment of FIG. 12, the present invention is not limited thereto. Any memory configured to work with a TCAM such that an entry in the TCAM points to a location in the memory storing the next state, the number of input characters, and the list output patterns can be used as well.

As described above, the compressed DFA can ignore next transitions of the original DFA that are to a state of depth less than or equal to m. These next transitions can be compensated for by encoding the corresponding states in a certain manner in the TCAM 1202. In the original DFA, a state s_(o) has a next transition to a state d_(o) of depth 1 on the input a only if the root has a goto transition to d_(o) on the input a. Furthermore, every state s_(o) in the DFA that does not have a goto transition on the input a will have a next transition to d_(o) on the input a. Hence, if the root node is represented in the TCAM 1202 such that every state will match the representation, the next transitions to a depth of 1 can be ignored. A “don't care” value (represented by ?) is used to indicate that any input character will be considered a match for the don't care value. A state id of all “don't care” values (“?? . . . ?”) will match every state. Similarly, a state so has a next transition on an input a to a state d_(o) of depth 2 only if string(d_(o))=ba, where d_(o)=goto (d_(o)′, a) and d_(o)′=goto (root, b). Thus, d_(o) is the parent of d_(o). Let i₁, . . . , i₈ be the binary representation of the input a. Thus, if the state id of d_(o) is don't care followed by i₁, . . . , i₈ (i.e., “????? i₁, . . . , i₈”) and the last 8 bits of the state id of s_(o) is i₁, . . . , i₈, then all of the next transitions to a state of depth 2 can be ignored. Along similar lines, if the trailing 8(m-1) bits of the state id of state s_(o) is dedicated to encode the last m-1 bytes of string(s_(o)) and the state id of the corresponding destination state d_(o) (of depth<=m) is also represented as don't care followed by the string(d_(o)), the next transitions to any of the states having a depth less than or equal to m can be ignored. This allows the amount of memory necessary to perform this algorithm to be optimized.

Because the TCAM 1202 uses a first match heuristic instead of a best match heuristic, the order on the entries in the TCAM 1202 is important to ensure correct implementation of the algorithm. All TCAM entries are sorted based on the state ids, with the transitions to states with state identifiers having fewer don't cares (‘?’) occurring higher up in the TCAM 1202. In the TCAM 1202, a transition that is higher than another transition has precedence over the other transition. Within entries having the same state identifiers, a goto transition to a state precedes any next transitions to the state. Furthermore, for the goto and next transitions, transitions to a state that is part of a larger pattern precede transitions to a state that is part of a smaller pattern, and transitions to a state based on a lower number of don't cares (‘?’) precede transitions to a state based on a higher number of don't cares (‘?’). This ensures that the longest possible transition (i.e., maximum number of characters processed) is given a higher priority than transitions that consume fewer characters.

Returning to FIG. 1, at step 150, an input stream is run on the compressed DFA in order to detect all occurrences of the patterns in the compressed DFA. The input stream is received and stored at an input buffer 1206 of the system 1200. The system 1200 includes two registers, an input pointer 1208 and a current state register 1210. Then input pointer 1208 points to the start of a portion of the input stream in the input buffer 1206 that is to be fed next to the DFA in the TCAM 1202. The current state register 1210 stores the current state of the DFA. When the input stream is received, the input pointer 1208 and the current state register 1210 are initialized to the start of the input buffer 1206 and the state zero, respectively.

In order to run the input stream on the compressed DFA, a certain number of bytes (characters) of the input stream and the current state of the compressed DFA are input to the TCAM 1202 from the input buffer 1206 and the current state register 1210, respectively as TCAM input 1212. The number of bytes of the input stream to be input to the TCAM 1202 can correspond to K and/or a width TW of the TCAM. It is also possible that K is determined based on TW when generating the compressed DFA. The TCAM input 1212 is compared to the TCAM entries, and if there is a matching entry, the index of the (first) matching entry gives a location in the SRAM 1204. That location contains the next state, the offset (input length) to advance the input pointer 1208, and a list of matched patterns (if any). The input pointer 1208 is advanced by the offset (input length), and the next state is stored in the current state register 1210. The patterns in the pattern list are output. For example, the patterns can be output to a table that keeps track of all of the patterns matched. If there is no matching entry in the TCAM 1202 for the TCAM input 1212, the current state register 1210 is set to the start state, and the input pointer 1208 is advanced by K. This process then repeats until the entire input stream is run on the compressed DFA. Thus, the compressed DFA transitions between states thereof based on multiple characters of the input stream in order to detect each occurrence of all of the patterns of the compressed DFA. The use of the TCAM 1202 to perform this algorithm gives a constant time search, as opposed to a linear time search that would result from using only an SRAM.

According to an embodiment of the present invention, when the input stream is a stream of data packets, it is possible to run the pattern matching algorithm on multiple flows simultaneously, where multiple flows converge and get re-ordered as packets or smaller data units. In this case, each flow can be uniquely identified by the 5-tuple (source ip, source port, dst ip, dst port, protocol). The current state information for each flow is stored in a flow tracking register. For the first packet in any stream or flow, the current state stored in the current state register 1210 is reset to zero, and the algorithm starts from there. At the end of each packet, the flow tracking register is updated with the current state of the flow. Then for any subsequent packets in that flow, the current state is retrieved from the flow tracking register and the current state register 1210 is updated accordingly. This is useful to track virus/worm signatures across an input stream (flow) split across multiple packets.

At step 160, regular expressions based on the detected patterns are identified. As described above, regular expressions are expressed as multiple sub patterns in the pattern database, and thus the compressed DFA. In order to identify regular expressions, it is possible to keep track of these multiple sub patterns and detect when these sub patterns occur at specific offsets as in the regular expression. The output patterns from the SRAM 1204 corresponding to any transition occurring in the DFA and detected in the TCAM 1202 can be represented in the form of pattern identifiers. These pattern identifiers are composed of a pattern id which is unique to all simple patterns belonging to one regular expression, a byte offset of the current pattern in the regular expression from the previous pattern, and the number of patterns yet to be looked at to flag that regular expression. These pattern identifiers can be stored in a lookup table, separate from the other patterns, that keeps track of all the current regular expressions matched. When all sub-patterns of a regular expression are detected at the appropriate offsets, the lookup table identifies that regular expression based on the sub patterns detected in the input stream. Thus, the multi-character multi-pattern pattern matching algorithm can be used to detected regular expressions, including those with fixed or variable length wildcards.

According to another embodiment of the present invention, the above described steps of the multi-character multi-pattern pattern matching algorithm may be implemented on an appropriately configured computer, for example, using well known computer processors, memory units, storage devices, computer software, and other components. A high level block diagram of such a computer is shown in FIG. 13. Computer 1302 contains a processor 1304 which controls the overall operation of computer 1302 by executing computer program instructions which define such operation. The computer program instructions may be stored in a storage device 1312 (e.g., magnetic disk) and loaded into memory 1310 when execution of the computer program instructions is desired. Thus, the operation of the computer will be defined by computer program instructions stored in memory 1310 and/or storage 1312 and the operation of the computer will be controlled by processor 1304 executing the computer program instructions. Computer 1302 also includes one or more network interfaces 1306 for communicating with other devices via a network. Computer 1302 also includes input/output 1308 which represents devices which allow for user interaction with the computer 1302 (e.g., display, keyboard, mouse, speakers, buttons, etc.). One skilled in the art will recognize that an implementation of an actual computer will contain other components as well, and that FIG. 13 is a high level representation of some of the components of such a computer for illustrative purposes. One skilled in the art will also recognize that dedicated hardware could be substituted for software, and that the functions described herein could be implemented using various combinations of hardware and software.

The foregoing Detailed Description is to be understood as being in every respect illustrative and exemplary, but not restrictive, and the scope of the invention disclosed herein is not to be determined from the Detailed Description, but rather from the claims as interpreted according to the full breadth permitted by the patent laws. It is to be understood that the embodiments shown and described herein are only illustrative of the principles of the present invention and that various modifications may be implemented by those skilled in the art without departing from the scope and spirit of the invention. Those skilled in the art could implement various other feature combinations without departing from the scope and spirit of the invention. 

1. A method of detecting each occurrence of a plurality of patterns in an input stream, comprising: receiving an input stream; and transitioning between states of a compressed deterministic finite state automaton (DFA) associated with the plurality of patterns, at least some transitions based on multiple characters of the input stream.
 2. The method of claim 1, wherein said transitioning step comprises: comparing a number of characters of the input stream to one or more transitions of the compressed DFA to find a matching transition; updating a current state of the DFA to a state associated with said matching transition; outputting any detected patterns associated with said matching transition; and repeating said comparing, updating, and outputting steps over a length of the input stream.
 3. The method of claim 2, wherein the plurality of patterns comprise sub patterns of at least one regular expression, the method further comprising: identifying the at least one regular expression based on the sub patterns being output as detected patterns and being separated from each other by specific offsets corresponding to the at least one regular expression.
 4. The method of claim 1, further comprising: generating said compressed DFA based on the plurality of patterns.
 5. The method of claim 4, wherein said generating step comprises: constructing an original DFA based on the plurality of patterns; and compressing the original DFA such that each state of the compressed DFA represents multiple consecutive states of the original DFA, and each transition between consecutive states of the compressed DFA is a combination of all transitions between the multiple consecutive states of the original DFA.
 6. The method of claim 5, wherein said compressing step comprises: determining core states of the original DFA to be states having a depth of a multiple of K and pattern ending states; generating a state of the compressed DFA corresponding to each core node of the original DFA; generating goto transitions between each of the states of the compressed DFA by combining multiple transitions between the core states in the original DFA; generating next transitions between states of the compressed DFA based on next transitions between states of the original DFA; and generating shallow states of the compressed DFA and corresponding transitions based on shallow states of the original DFA.
 7. The method of claim 6, wherein said step of generating next transitions comprises: determining whether a next transition of the original DFA is to a safe state of the original DFA; if the next transition of the original DFA is to a safe state of the original DFA, generating a forward next transition between states in the compressed DFA based on the next transition of the original DFA; and if the next transition of the original DFA is to an unsafe state of the original DFA, generating a backward next transition between states in the compressed DFA based on the next transition of the original DFA.
 8. The method of claim 7, wherein said step of determining whether a next transition of the original DFA is to a safe state of the original DFA comprises: if a state of the original DFA is core state, determining the state of the original DFA to be safe; if a state of the original DFA and its children states between said state and a next core state have no next transitions to any state having a depth greater than a specified value, determining the state of the original DFA to be safe; and if a state of the original DFA or any of its children states have any next transitions to any state having a depth greater than the specified value and the state of the original DFA is not a core state, determining that the state of the original DFA is unsafe.
 9. The method of claim 6, wherein said step of generating next transitions comprises: generating next transitions between states of the compressed DFA based only on next transitions to states of the original DFA having a depth greater than a specified value.
 10. The method of claim 6, wherein said step of generating shallow states comprises: generating a shallow state in the compressed DFA corresponding to each state of the original DFA having a depth less than K; generating goto transitions between a root state of the compressed DFA and each shallow state of the compressed DFA using “don't care” values; and generating goto transitions between each shallow state of the compressed DFA and a state of the compressed DFA corresponding to one of the respective core states of the original DFA.
 11. An apparatus comprising: a Ternary Content Addressable Memory (TCAM) storing entries associated with a compressed deterministic finite state automaton (DFA), each entry including a state identifier of a state of the compressed DFA and a multiple character transition string defining a transition from that state of the compressed DFA.
 12. The apparatus of claim 11, further comprising: a memory storing a next state identifier, an input length value, and a detected patterns list corresponding to each entry of the TCAM.
 13. The apparatus of claim 12, wherein said memory comprises a Static Random Access Memory (SRAM), the apparatus further comprising: an input buffer storing an input stream and configured to provide the input stream to the TCAM multiple characters at a time; a first register storing an input pointer which indicates a portion of the input stream to be provided to the TCAM; and a second register storing a current state of the compressed DFA and configured to provide the current state of the compressed DFA to the TCAM.
 14. The apparatus of claim 13, wherein the TCAM is configured to compare multiple characters of the input stream and the current state of the compressed DFA to the entries stored therein, and when an entry matches the input characters and current state, the TCAM returns an address of a memory location in the SRAM of the corresponding next state identifier, input value length, and detected patterns list.
 15. The apparatus of claim 14, wherein the second register is configured to save the corresponding next state identifier as the current state, and the first register is configured to control how many characters of the input stream are input to the TCAM based on the corresponding input value length.
 16. The apparatus of claim 15, wherein the entries of the TCAM are ordered based on precedence and the TCAM returns the address of the memory location in the SRAM corresponding to the first matching entry to the input characters and current state.
 17. The apparatus of claim 13, wherein said input stream comprises a stream of data packets from multiple flows, the system further comprising: a third register storing the current state of each flow and configured to update the second register based on the flow identified for each data packet.
 18. A computer readable medium storing computer program instructions for performing a method of detecting each occurrence of a plurality of patterns in an input stream, said computer program instructions defining the steps comprising: receiving an input stream; and transitioning between states of a compressed deterministic finite state automaton (DFA) associated with the plurality of patterns, at least some transitions based on multiple characters of the input stream.
 19. The computer readable medium of claim 18, wherein the computer program instructions defining the step of transitioning between states of the compressed DFA comprise computer program instructions defining the steps of: comparing a number of characters of the input stream to one or more transitions of the compressed DFA to find a matching transition; updating a current state of the DFA to a state associated with said matching transition; outputting any detected patterns associated with said matching transition; and repeating said comparing, updating, and outputting steps over a length of the input stream.
 20. The computer readable medium of claim 18, further comprising computer program instructions defining the steps of: constructing an original DFA based on the plurality of patterns; and generating the compressed DFA by compressing the original DFA such that each state of the compressed DFA represents multiple consecutive states of the original DFA, and each transition between consecutive states of the compressed DFA is a combination of all transitions between the multiple consecutive states of the original DFA. 